home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / esc.jar / com / extensibility / exv / SchemaWrapper.class (.txt) < prev   
Encoding:
Java Class File  |  2000-06-30  |  9.2 KB  |  517 lines
  1. package com.extensibility.exv;
  2.  
  3. import com.extensibility.util.StringUtilities;
  4. import com.extensibility.xml.BaseDeclaration;
  5. import com.extensibility.xml.ExternalSubset;
  6. import com.extensibility.xml.ParserException;
  7. import com.extensibility.xml.Schema;
  8. import com.extensibility.xml.SchemaUtilities;
  9. import com.extensibility.xml.URI;
  10. import java.io.File;
  11. import java.io.Serializable;
  12. import java.io.StringWriter;
  13. import java.net.URL;
  14. import java.util.Enumeration;
  15. import java.util.ResourceBundle;
  16. import java.util.Vector;
  17.  
  18. public class SchemaWrapper implements Serializable {
  19.    public static final int FLAVOR_VIRGIN = 0;
  20.    public static final int FLAVOR_STRING = 1;
  21.    public static final int FLAVOR_URL = 2;
  22.    public static final int FLAVOR_FILE = 3;
  23.    static final int FLAVOR_OTHER = -1;
  24.    private int uriFlavor;
  25.    static final String XML_RESOURCE_PKG = "com.extensibility.xa.rsc.";
  26.    private ResourceBundle parserErrorBundle;
  27.    private Schema schema;
  28.    private String flavor;
  29.    private boolean valid;
  30.    private boolean wellFormed;
  31.    private Vector parseErrors;
  32.    private String schemaPath;
  33.    protected URI physicalURI;
  34.    protected URI logicalURI;
  35.    private MultiModule group;
  36.  
  37.    public SchemaWrapper(String var1) throws SchemaException {
  38.       this.uriFlavor = 0;
  39.       this.schema = null;
  40.       this.flavor = "";
  41.       this.valid = false;
  42.       this.wellFormed = false;
  43.       this.parseErrors = null;
  44.       this.physicalURI = null;
  45.       this.logicalURI = null;
  46.       this.group = null;
  47.       if (var1 == null) {
  48.          throw new SchemaException("Cannot initialize the schema to null");
  49.       } else {
  50.          try {
  51.             this.uriFlavor = 1;
  52.             this.init();
  53.             var1 = var1.substring(StringUtilities.skipWhite(var1, 0));
  54.             this.physicalURI = new URI(var1);
  55.             this.logicalURI = new URI("http://Schema");
  56.             this.initCreate();
  57.          } catch (Exception var3) {
  58.             this.printConstrException(var3);
  59.             throw new SchemaException("Cannot initialize the schema", var3);
  60.          }
  61.       }
  62.    }
  63.  
  64.    public SchemaWrapper(URL var1) throws SchemaException {
  65.       this.uriFlavor = 0;
  66.       this.schema = null;
  67.       this.flavor = "";
  68.       this.valid = false;
  69.       this.wellFormed = false;
  70.       this.parseErrors = null;
  71.       this.physicalURI = null;
  72.       this.logicalURI = null;
  73.       this.group = null;
  74.       if (var1 == null) {
  75.          throw new SchemaException("Cannot initialize the schema to null");
  76.       } else {
  77.          try {
  78.             this.uriFlavor = 2;
  79.             this.init();
  80.             this.physicalURI = new URI(var1);
  81.             this.logicalURI = this.physicalURI;
  82.             this.initCreate();
  83.          } catch (Exception var3) {
  84.             this.printConstrException(var3);
  85.             throw new SchemaException("Cannot initialize the schema", var3);
  86.          }
  87.       }
  88.    }
  89.  
  90.    SchemaWrapper(URI var1, URI var2) throws SchemaException {
  91.       this.uriFlavor = 0;
  92.       this.schema = null;
  93.       this.flavor = "";
  94.       this.valid = false;
  95.       this.wellFormed = false;
  96.       this.parseErrors = null;
  97.       this.physicalURI = null;
  98.       this.logicalURI = null;
  99.       this.group = null;
  100.  
  101.       try {
  102.          this.uriFlavor = -1;
  103.          this.init();
  104.          this.physicalURI = var1;
  105.          this.logicalURI = var2;
  106.          this.initCreate();
  107.       } catch (Exception var4) {
  108.          this.printConstrException(var4);
  109.          throw new SchemaException("Cannot initialize the schema", var4);
  110.       }
  111.    }
  112.  
  113.    public SchemaWrapper(File var1) throws SchemaException {
  114.       this(new URI(var1), new URI(var1.getName()));
  115.       this.uriFlavor = 3;
  116.    }
  117.  
  118.    SchemaWrapper(File var1, MultiModule var2) throws SchemaException {
  119.       this(var1);
  120.       this.group = var2;
  121.    }
  122.  
  123.    public SchemaWrapper() throws SchemaException {
  124.       this.uriFlavor = 0;
  125.       this.schema = null;
  126.       this.flavor = "";
  127.       this.valid = false;
  128.       this.wellFormed = false;
  129.       this.parseErrors = null;
  130.       this.physicalURI = null;
  131.       this.logicalURI = null;
  132.       this.group = null;
  133.  
  134.       try {
  135.          this.uriFlavor = 0;
  136.          this.init();
  137.       } catch (Exception var2) {
  138.          this.printConstrException(var2);
  139.          throw new SchemaException("Cannot initialize the schema", var2);
  140.       }
  141.    }
  142.  
  143.    public MultiModule getGroup() {
  144.       return this.group;
  145.    }
  146.  
  147.    public void setGroup(MultiModule var1) {
  148.       this.group = var1;
  149.    }
  150.  
  151.    public void setSchema(String var1) throws SchemaException {
  152.       if (var1 == null) {
  153.          throw new SchemaException("Cannot set the schema to null");
  154.       } else {
  155.          this.group.changedSchema(this.getFileName());
  156.          this.uriFlavor = 1;
  157.          String var2 = var1.substring(StringUtilities.skipWhite(var1, 0));
  158.          this.physicalURI = URI.makeStringURI(var2);
  159.          this.logicalURI = new URI("http://Schema");
  160.          this.flavor = SchemaUtilities.getFlavor(this.physicalURI, true);
  161.          if (SchemaFlavor.isFlavorSupported(this.flavor)) {
  162.             this.schema = new Schema(this.logicalURI, this.flavor);
  163.          } else {
  164.             throw new SchemaException("Flavor not supported, yet");
  165.          }
  166.       }
  167.    }
  168.  
  169.    public void setSchema(URL var1) throws SchemaException {
  170.       if (var1 == null) {
  171.          throw new SchemaException("Cannot set the schema to null");
  172.       } else {
  173.          this.group.changedSchema(this.getFileName());
  174.          this.uriFlavor = 2;
  175.          this.physicalURI = new URI(var1);
  176.          this.logicalURI = this.physicalURI;
  177.          this.flavor = SchemaUtilities.getFlavor(this.physicalURI, true);
  178.          if (!SchemaFlavor.isFlavorSupported(this.flavor)) {
  179.             throw new SchemaException("Flavor not supported, yet");
  180.          } else {
  181.             this.schema = new Schema(this.logicalURI, this.flavor);
  182.          }
  183.       }
  184.    }
  185.  
  186.    public void setSchemaPath(String var1) {
  187.       this.schemaPath = var1;
  188.    }
  189.  
  190.    public void validate() {
  191.       this.checkSchema();
  192.    }
  193.  
  194.    public String getFlavor() {
  195.       return this.flavor;
  196.    }
  197.  
  198.    public boolean isValid() {
  199.       return this.valid;
  200.    }
  201.  
  202.    public boolean isWellFormed() {
  203.       return this.wellFormed;
  204.    }
  205.  
  206.    Enumeration getIncludedModules() {
  207.       Vector var1 = new Vector();
  208.       Enumeration var2 = this.schema.getDeclarations();
  209.  
  210.       while(var2.hasMoreElements()) {
  211.          BaseDeclaration var3 = (BaseDeclaration)var2.nextElement();
  212.          if (var3 instanceof ExternalSubset) {
  213.             var1.addElement(var3);
  214.          }
  215.       }
  216.  
  217.       if (var1.isEmpty()) {
  218.          return null;
  219.       } else {
  220.          return var1.elements();
  221.       }
  222.    }
  223.  
  224.    public Vector getDeclErrors() {
  225.       if (this.schema == null) {
  226.          return null;
  227.       } else {
  228.          Vector var1 = new Vector();
  229.          Enumeration var2 = this.schema.getDeclarations();
  230.  
  231.          while(var2.hasMoreElements()) {
  232.             BaseDeclaration var3 = (BaseDeclaration)var2.nextElement();
  233.             if (var3.hasErrors() && !this.isURINotParseable(var3.getURI())) {
  234.                Enumeration var4 = var3.getErrors().elements();
  235.  
  236.                while(var4.hasMoreElements()) {
  237.                   var1.addElement(var4.nextElement());
  238.                }
  239.             }
  240.          }
  241.  
  242.          return var1;
  243.       }
  244.    }
  245.  
  246.    public int getDeclErrorsCount() {
  247.       int var1 = 0;
  248.       Enumeration var2 = this.schema.getDeclarations();
  249.  
  250.       while(var2.hasMoreElements()) {
  251.          BaseDeclaration var3 = (BaseDeclaration)var2.nextElement();
  252.          if (var3.hasErrors() && !this.isURINotParseable(var3.getURI())) {
  253.             ++var1;
  254.          }
  255.       }
  256.  
  257.       return var1;
  258.    }
  259.  
  260.    public Vector getDeclErrorsDesc() {
  261.       Vector var1 = new Vector();
  262.       Enumeration var2 = this.getDeclErrors().elements();
  263.  
  264.       while(var2.hasMoreElements()) {
  265.          var1.addElement(((ParserException)var2.nextElement()).getMessage());
  266.       }
  267.  
  268.       return var1.size() > 0 ? var1 : null;
  269.    }
  270.  
  271.    public Vector getParseErrors() {
  272.       if (this.parseErrors == null) {
  273.          return null;
  274.       } else {
  275.          Vector var1 = new Vector(this.parseErrors.size());
  276.          Enumeration var2 = this.parseErrors.elements();
  277.  
  278.          while(var2.hasMoreElements()) {
  279.             var1.addElement((ParserException)var2.nextElement());
  280.          }
  281.  
  282.          return var1;
  283.       }
  284.    }
  285.  
  286.    public int getParseErrorsCount() {
  287.       return this.parseErrors != null ? this.parseErrors.size() : 0;
  288.    }
  289.  
  290.    public Vector getParseErrorsDesc() {
  291.       if (this.parseErrors == null) {
  292.          return null;
  293.       } else {
  294.          Vector var1 = new Vector(this.parseErrors.size());
  295.          Enumeration var2 = this.parseErrors.elements();
  296.  
  297.          while(var2.hasMoreElements()) {
  298.             var1.addElement(((ParserException)var2.nextElement()).getMessage());
  299.          }
  300.  
  301.          return var1;
  302.       }
  303.    }
  304.  
  305.    public String getResults() {
  306.       if (this.schema != null) {
  307.          if (!this.isValid()) {
  308.             this.schema.setPrintValidatedBy(false);
  309.             this.schema.setShowErrors(true);
  310.             return this.writeSchema();
  311.          } else {
  312.             return this.getSchemaSource();
  313.          }
  314.       } else {
  315.          return "";
  316.       }
  317.    }
  318.  
  319.    public String convertToDTD() {
  320.       try {
  321.          String var1 = this.convertTo(SchemaFlavor.DTD);
  322.          return var1;
  323.       } catch (SchemaException var3) {
  324.          Object var2 = null;
  325.          return (String)var2;
  326.       }
  327.    }
  328.  
  329.    public String convertToSOX() {
  330.       try {
  331.          String var1 = this.convertTo(SchemaFlavor.SOX);
  332.          return var1;
  333.       } catch (SchemaException var3) {
  334.          Object var2 = null;
  335.          return (String)var2;
  336.       }
  337.    }
  338.  
  339.    public String convertToXDR() {
  340.       try {
  341.          String var1 = this.convertTo(SchemaFlavor.XDR);
  342.          return var1;
  343.       } catch (SchemaException var3) {
  344.          Object var2 = null;
  345.          return (String)var2;
  346.       }
  347.    }
  348.  
  349.    public String convertToXSD() {
  350.       try {
  351.          String var1 = this.convertTo("xsd");
  352.          return var1;
  353.       } catch (SchemaException var3) {
  354.          Object var2 = null;
  355.          return (String)var2;
  356.       }
  357.    }
  358.  
  359.    public String convertToBIZ() {
  360.       try {
  361.          String var1 = this.convertTo(SchemaFlavor.BIZ);
  362.          return var1;
  363.       } catch (SchemaException var3) {
  364.          Object var2 = null;
  365.          return (String)var2;
  366.       }
  367.    }
  368.  
  369.    public String convertTo(String var1) throws SchemaException {
  370.       if (SchemaFlavor.isFlavorSupported(var1)) {
  371.          throw new SchemaException("Flavor not supported, yet.");
  372.       } else if (!var1.equalsIgnoreCase(var1)) {
  373.          if (this.schema != null && this.isValid()) {
  374.             this.schema.setFlavor(var1);
  375.             return this.getSchemaSource();
  376.          } else {
  377.             return null;
  378.          }
  379.       } else {
  380.          return this.getSchemaSource();
  381.       }
  382.    }
  383.  
  384.    public String getSchemaSource() {
  385.       if (this.schema != null) {
  386.          this.schema.setPrintValidatedBy(true);
  387.          this.schema.setShowErrors(false);
  388.          return this.writeSchema();
  389.       } else {
  390.          return "";
  391.       }
  392.    }
  393.  
  394.    public String getFileName() {
  395.       return this.uriFlavor > 1 && this.logicalURI != null ? this.logicalURI.getShortName() : "";
  396.    }
  397.  
  398.    protected Schema getSchema() {
  399.       return this.schema;
  400.    }
  401.  
  402.    private void init() throws Exception {
  403.       this.parserErrorBundle = ResourceBundle.getBundle("com.extensibility.xa.rsc.ParserExceptions");
  404.       ParserException.setMessageBundle(this.parserErrorBundle);
  405.    }
  406.  
  407.    private void initCreate() throws SchemaException {
  408.       try {
  409.          this.flavor = SchemaUtilities.getFlavor(this.physicalURI, true);
  410.          if (SchemaFlavor.isFlavorSupported(this.flavor)) {
  411.             this.schema = new Schema(this.logicalURI, this.flavor);
  412.          } else {
  413.             throw new SchemaException("Flavor not supported, yet");
  414.          }
  415.       } catch (Exception var2) {
  416.          throw new SchemaException("Problems occured when thying to initialize the schema", var2);
  417.       }
  418.    }
  419.  
  420.    private void checkSchema() {
  421.       this.valid = true;
  422.       this.wellFormed = true;
  423.       if (this.schema != null) {
  424.          this.schema.removeAllDeclarations();
  425.          this.schema.setSchemaPath(this.schemaPath);
  426.          this.schema.setPrintValidatedBy(true);
  427.  
  428.          try {
  429.             this.schema.setShowErrors(true);
  430.             this.schema.parse(this.physicalURI, this.logicalURI, this.schema.getCount(), new Boolean(false));
  431.             this.schema.doSecondPassValidation(this.physicalURI);
  432.          } catch (Throwable var3) {
  433.             this.valid = false;
  434.             return;
  435.          }
  436.  
  437.          this.filterParseErrors();
  438.          this.checkAll();
  439.          this.parseErrors = this.schema.getParseErrors();
  440.          int var1 = this.getDeclErrorsCount();
  441.          int var2 = this.schema.getCount();
  442.          if (!this.parseErrors.isEmpty() || var1 != 0) {
  443.             this.valid = false;
  444.          }
  445.       } else {
  446.          this.valid = false;
  447.          this.wellFormed = false;
  448.       }
  449.  
  450.    }
  451.  
  452.    private void checkAll() {
  453.       Enumeration var1 = this.schema.getDeclarations();
  454.  
  455.       while(var1.hasMoreElements()) {
  456.          BaseDeclaration var2 = (BaseDeclaration)var1.nextElement();
  457.          this.schema.checkForErrors(var2);
  458.       }
  459.  
  460.       this.schema.checkForErrors((BaseDeclaration)null);
  461.    }
  462.  
  463.    private String writeSchema() {
  464.       StringWriter var1 = new StringWriter();
  465.  
  466.       try {
  467.          this.schema.write(var1);
  468.          String var2 = var1.toString();
  469.          return var2;
  470.       } catch (Exception var3) {
  471.          return null;
  472.       }
  473.    }
  474.  
  475.    private void printConstrException(Exception var1) {
  476.       System.out.println(var1);
  477.       ((Throwable)var1).printStackTrace();
  478.    }
  479.  
  480.    private void filterParseErrors() {
  481.       Vector var1 = this.schema.getParseErrors();
  482.       Vector var2 = new Vector(var1.size());
  483.       Enumeration var3 = var1.elements();
  484.  
  485.       while(var3.hasMoreElements()) {
  486.          ParserException var4 = (ParserException)var3.nextElement();
  487.          if (this.isURINotParseable(var4.getURI())) {
  488.             var2.addElement(var4);
  489.          }
  490.       }
  491.  
  492.       Enumeration var5 = var2.elements();
  493.  
  494.       while(var5.hasMoreElements()) {
  495.          var1.removeElement(var5.nextElement());
  496.       }
  497.  
  498.    }
  499.  
  500.    private boolean isURINotParseable(URI var1) {
  501.       return this.checkURI(var1) || (var1.getBaseURI() != null ? this.isURINotParseable(var1.getBaseURI()) : false);
  502.    }
  503.  
  504.    private boolean checkURI(URI var1) {
  505.       Enumeration var2 = this.group.getNotParseable().elements();
  506.  
  507.       while(var2.hasMoreElements()) {
  508.          SchemaWrapper var3 = (SchemaWrapper)var2.nextElement();
  509.          if (var1.equals(var3.physicalURI)) {
  510.             return true;
  511.          }
  512.       }
  513.  
  514.       return false;
  515.    }
  516. }
  517.